import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.InputMismatchException;

/**
 * @author Egor Kulikov (egor@egork.net)
 */
public class Task13 {
	@SuppressWarnings({"FieldCanBeLocal", "UnusedDeclaration"})
	private InputReader in;
	private PrintWriter out;

	private void solve() {
		int arraySize = /*20001;*/in.readInt();
		int[] array = /*new int[arraySize];*/in.readIntArray(arraySize);
		for (int i = 0; i < arraySize; i++)
			array[i] += /*i;*/ 10000;
		int[] p = new int[20001];
		for (int i = 0; i < arraySize; i++)
			p[array[i]] = 1;
		int[] p2 = multiply(p, p);
		for (int i = 0; i < arraySize; i++)
			p2[2 * array[i]] -= 3;
		int[] result = multiply(p2, p);
		for (int i = 0; i < arraySize; i++)
			result[array[i] * 3] += 2;
//		long sum = 0;
		for (int i = 0; i <= 60000; i++) {
			if (result[i] != 0) {
//				sum += result[i];
				if (result[i] % 6 != 0)
					throw new RuntimeException();
				out.println((i - 30000) + " : " + result[i] / 6);
			}
		}
//		out.println(sum);
	}

	private int[] multiply(int[] p, int[] q) {
		int[] result = new int[p.length + q.length - 1];
		return multiply(p, 0, p.length, q, 0, q.length, result);
	}

	private int[] multiply(int[] p, int fromP, int toP, int[] q, int fromQ, int toQ, int[] result) {
		while (fromP < toP && p[fromP] == 0)
			fromP++;
		while (fromP < toP && p[toP - 1] == 0)
			toP--;
		while (fromQ < toQ && q[fromQ] == 0)
			fromQ++;
		while (fromQ < toQ && q[toQ - 1] == 0)
			toQ--;
		int pLength = toP - fromP;
		int qLength = toQ - fromQ;
		int n = Math.max(pLength, qLength) / 2;
		if (n <= 10) {
			for (int i = fromP; i < toP; i++) {
				for (int j = fromQ; j < toQ; j++)
					result[i + j] += p[i] * q[j];
			}
			return result;
		}
		if (pLength == 0)
			return result;
		if (qLength == 0)
			return result;
		if (n == 0) {
			result[fromP + fromQ] += p[fromP] * q[fromQ];
//			return new int[]{p[fromP] * q[fromQ]};
			return result;
		}
		int[] a;
		int fromA;
		int toA;
		int[] b;
		int fromB;
		int toB;
		if (pLength > n) {
			a = p;
			fromA = fromP;
			toA = fromP + n;
			b = p;
			fromB = fromP + n;
			toB = toP;
		} else {
			a = p;
			fromA = fromP;
			toA = toP;
			b = p;
			fromB = toP;
			toB = toP;
		}
		int[] c;
		int fromC;
		int toC;
		int[] d;
		int fromD;
		int toD;
		if (qLength > n) {
			c = q;
			fromC = fromQ;
			toC = fromQ + n;
			d = q;
			fromD = fromQ + n;
			toD = toQ;
		} else {
			c = q;
			fromC = fromQ;
			toC = toQ;
			d = q;
			fromD = toQ;
			toD = toQ;
		}
		int[] ac = multiply(a, fromA, toA, c, fromC, toC, result);
		int[] bd = multiply(b, fromB, toB, d, fromD, toD, result);
		int aLength = toA - fromA;
		int bLength = toB - fromB;
		int[] apb = new int[Math.max(aLength, bLength)];
		for (int i = 0, j = fromA; i < aLength; i++, j++)
			apb[i] += a[j];
		for (int i = 0, j = fromB; i < bLength; i++, j++)
			apb[i] += b[j];
		int cLength = toC - fromC;
		int dLength = toD - fromD;
		int[] cpd = new int[Math.max(cLength, dLength)];
		for (int i = 0, j = fromC; i < cLength; i++, j++)
			cpd[i] += c[j];
		for (int i = 0, j = fromD; i < dLength; i++, j++)
			cpd[i] += d[j];
		int[] abcd = multiply(apb, cpd);
		int acLength = Math.min(aLength + cLength - 1, abcd.length);
		int acShift = fromA + fromC;
		int bdLength = Math.min(bLength + dLength - 1, abcd.length);
		int bdShift = fromB + fromD;
		for (int i = 0, j = acShift; i < acLength; i++, j++)
			abcd[i] -= ac[j];
		for (int j = 0, i = bdShift; j < bdLength; j++, i++)
			abcd[j] -= bd[i];
//		int[] result = new int[pLength + qLength - 1];
		int shift = fromP + fromQ + n;
//		for (int i = 0; i < ac.length && shift + i < result.length; i++)
//			result[shift + i] += ac[i];
//		for (int i = 0; i < bd.length && i + 2 * n < result.length; i++)
//			result[i + 2 * n] += bd[i];
		for (int i = 0, j = shift; i < abcd.length/* && i + shift < result.length*/; i++, j++)
			result[j] += abcd[i];
		return result;
	}

	public static void main(String[] args) {
		new Task13().run();
	}

	private Task13() {
		@SuppressWarnings({"UnusedDeclaration"})
		String id = getClass().getName().toLowerCase();
		//noinspection EmptyTryBlock
		try {
//			System.setIn(new FileInputStream(id + ".in"));
//			System.setOut(new PrintStream(new FileOutputStream(id + ".out")));
//			System.setIn(new FileInputStream("input.txt"));
//			System.setOut(new PrintStream(new FileOutputStream("output.txt")));
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
		in = new InputReader(System.in);
		out = new PrintWriter(System.out);
	}

	private void run() {
		//noinspection InfiniteLoopStatement
//		while (true)
//		int testCount = in.readInt();
//		for (int i = 0; i < testCount; i++)
		solve();
		exit();
	}

	@SuppressWarnings({"UnusedDeclaration"})
	private void exit() {
		out.close();
		System.exit(0);
	}

	@SuppressWarnings({"UnusedDeclaration"})
	private static class InputReader {
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar, numChars;

		public InputReader(InputStream stream) {
			this.stream = stream;
		}

		public int read() {
			if (numChars == -1)
				throw new InputMismatchException();
			if (curChar >= numChars) {
				curChar = 0;
				try {
					numChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public int readInt() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public long readLong() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public String readString() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuffer res = new StringBuffer();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		private boolean isSpaceChar(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		private String readLine0() {
			StringBuffer buf = new StringBuffer();
			int c = read();
			while (c != '\n' && c != -1) {
				if (c != '\r')
					buf.appendCodePoint(c);
				c = read();
			}
			return buf.toString();
		}

		public String readLine() {
			String s = readLine0();
			while (s.trim().length() == 0)
				s = readLine0();
			return s;
		}

		public String readLine(boolean ignoreEmptyLines) {
			if (ignoreEmptyLines)
				return readLine();
			else
				return readLine0();
		}

		public BigInteger readBigInteger() {
			try {
				return new BigInteger(readString());
			} catch (NumberFormatException e) {
				throw new InputMismatchException();
			}
		}

		public char readCharacter() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			return (char) c;
		}

		public double readDouble() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			double res = 0;
			while (!isSpaceChar(c) && c != '.') {
				if (c == 'e' || c == 'E')
					return res * Math.pow(10, readInt());
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			if (c == '.') {
				c = read();
				double m = 1;
				while (!isSpaceChar(c)) {
					if (c == 'e' || c == 'E')
						return res * Math.pow(10, readInt());
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					m /= 10;
					res += (c - '0') * m;
					c = read();
				}
			}
			return res * sgn;
		}

		public int[] readIntArray(int size) {
			int[] array = new int[size];
			for (int i = 0; i < size; i++)
				array[i] = readInt();
			return array;
		}

		public long[] readLongArray(int size) {
			long[] array = new long[size];
			for (int i = 0; i < size; i++)
				array[i] = readLong();
			return array;
		}

		public double[] readDoubleArray(int size) {
			double[] array = new double[size];
			for (int i = 0; i < size; i++)
				array[i] = readDouble();
			return array;
		}

		public String[] readStringArray(int size) {
			String[] array = new String[size];
			for (int i = 0; i < size; i++)
				array[i] = readString();
			return array;
		}

		public char[][] readTable(int rowCount, int columnCount) {
			char[][] table = new char[rowCount][columnCount];
			for (int i = 0; i < rowCount; i++) {
				for (int j = 0; j < columnCount; j++)
					table[i][j] = readCharacter();
			}
			return table;
		}

		public void readIntArrays(int[]... arrays) {
			for (int i = 0; i < arrays[0].length; i++) {
				for (int j = 0; j < arrays.length; j++)
					arrays[j][i] = readInt();
			}
		}
	}
}
